﻿<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">

<head>
	<title xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory">第3章 事件表示方法</title>
	<link rel="stylesheet" href="css/espertech.css" type="text/css">
	<meta xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" name="generator" content="DocBook XSL-NS Stylesheets V1.74.0">
	<meta xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" http-equiv="Content-Type" content="text/html; charset=UTF-8">
	<link rel="home" href="index.html" title="Esper参考文档">
	<link rel="up" href="index.html" title="Esper参考文档">
	<link rel="prev" href="processingmodel.html" title="第2章 基本概念">
	<link rel="next" href="context.html" title="第4章 上下文与上下文分区">
</head>

<body>
	<p xmlns:d="http://docbook.org/ns/docbook" id="title"><a href="./index.html" class="site_href"><strong>www.espertech.com</strong></a><a href="http://www.espertech.com/esper/esper-documentation/" class="doc_href"><strong>文档</strong></a></p>
	<ul xmlns:d="http://docbook.org/ns/docbook" class="docnav">
		<li class="previous"><a accesskey="p" href="processingmodel.html"><strong>上一章</strong></a></li>
		<li class="next"><a accesskey="n" href="context.html"><strong>下一章</strong></a></li>
	</ul>
	<div class="chapter" lang="en-US">
		<div class="titlepage">
			<div>
				<div>
					<h2 class="title"><a id="event_representation"></a>第3章 事件表示方法</h2>
				</div>
			</div>
		</div>
		<div class="toc">
			<dl>
				<dt><span class="sect1"><a href="event_representation.html#eventrep_intro">3.1. 事件的底层Java对象</a></span></dt>
				<dt><span class="sect1"><a href="event_representation.html#eventrep-properties">3.2. 事件属性</a></span></dt>
				<dd>
					<dl>
						<dt><span class="sect2"><a href="event_representation.html#eventrep-properties-escaping">3.2.1. 转义字符</a></span></dt>
						<dt><span class="sect2"><a href="event_representation.html#eventrep-properties-expression">3.2.2. 表达式作为键或索引值</a></span></dt>
					</dl>
				</dd>
				<dt><span class="sect1"><a href="event_representation.html#eventrep-dyncproperties">3.3. 动态事件属性</a></span></dt>
				<dt><span class="sect1"><a href="event_representation.html#eventrep-fragment">3.4. 片段与片段类型</a></span></dt>
				<dt><span class="sect1"><a href="event_representation.html#eventrep_comparing">3.5. 事件表示方法的比较</a></span></dt>
				<dd>
					<dl>
						<dt><span class="sect2"><a href="event_representation.html#eventrep_comparing_incoming">3.5.1. 输入事件</a></span></dt>
						<dt><span class="sect2"><a href="event_representation.html#eventrep_comparing_outgoing">3.5.2. 输出事件</a></span></dt>
						<dt><span class="sect2"><a href="event_representation.html#eventrep_comparing_schema">3.5.3. 模式</a></span></dt>
						<dt><span class="sect2"><a href="event_representation.html#eventrep_comparing_advantages">3.5.4. 对比表</a></span></dt>
					</dl>
				</dd>
				<dt><span class="sect1"><a href="event_representation.html#eventrep-generictuple">3.6. 通用元组支持</a></span></dt>
				<dt><span class="sect1"><a href="event_representation.html#eventrep-update">3.7. 事件更新、合并与版本控制</a></span></dt>
				<dt><span class="sect1"><a href="event_representation.html#eventrep-coarse">3.8. 粗粒度事件</a></span></dt>
				<dt><span class="sect1"><a href="event_representation.html#eventrep-insertinto">3.9. 通过Insert Into实例化并填充事件对象</a></span></dt>
				<dt><span class="sect1"><a href="event_representation.html#eventrep_identification">3.10. 事件类型唯一性</a></span></dt>
			</dl>
		</div>
		<p>
			本节概述了建模和表示事件的不同方法。
		</p>
		<p>
			EPL使用术语<strong>事件类型</strong>来描述事件表示可用的类型信息。
		</p>
		<p>
			您的应用程序可以使用配置对象配置预定义的事件类型，或使用<code class="literal">create schema</code>动态添加事件类型。
		</p>
		<p>
			EPL的<code class="literal">create schema</code>语法允许在运行时使用EPL声明事件类型，参见<a class="xref" href="epl_clauses.html#epl_createschema" title="5.15. 声明事件类型：Create Schema">第5.15节"声明事件类型：Create Schema"</a>。
		</p>
		<p>
			<a class="xref" href="apiruntime.html#apiruntime-statement-event" title="16.5.5. 事件与事件类型">第16.5.5节"事件与事件类型"</a>解释了事件类型如何在语句中和运行时输出的交付事件中变得可见。
		</p>
		<div class="sect1" lang="en-US">
			<div class="titlepage">
				<div>
					<div>
						<h2 class="title"><a id="eventrep_intro"></a>3.1. 事件的底层Java对象</h2>
					</div>
				</div>
			</div><a id="d0e2577" class="indexterm"></a>
			<p>
				事件是对过去发生动作或状态变化不可变的记录。事件属性捕获事件的状态信息。
			</p>
			<p>
				在EPL中，事件可以由以下任何底层Java对象表示(NEsper .NET参见<a class="xref" href="appendix_dotnet.html#appendix_dotnet_eventrep_intro" title="J.7. .NET事件的底层对象">第J.7节".NET事件的底层对象"</a>)：
			</p>
			<div class="table"><a id="d0e2588"></a>
				<p class="title"><b>表3.1. 事件的底层Java对象</b></p>
				<div class="table-contents">
					<table summary="Event Underlying Java Objects" border="1">
						<colgroup>
							<col>
							<col>
						</colgroup>
						<thead>
							<tr>
								<th>Java类</th>
								<th>描述</th>
							</tr>
						</thead>
						<tbody>
							<tr>
								<td><code class="literal">java.lang.Object</code></td>
								<td>任何遵循JavaBean规范的Java POJO(普通Java对象)；不遵循JavaBean规范的遗留Java类也可以作为事件。</td>
							</tr>
							<tr>
								<td><code class="literal">java.util.Map</code></td>
								<td>Map事件是实现<code class="literal">java.util.Map</code>接口的对象，其中每个map条目都是一个属性值。</td>
							</tr>
							<tr>
								<td><code class="literal">Object[] (对象数组)</code></td>
								<td>对象数组事件是对象数组(类型为<code class="literal">Object[]</code>)，其中每个数组元素都是一个属性值。</td>
							</tr>
							<tr>
								<td><code class="literal">String</code>或<code class="literal">JsonEventUnderlying</code></td>
								<td>JSON事件是字符串类型的JSON格式文档。解析后的JSON文档可用并实现<code class="literal">JsonEventUnderlying</code>接口。</td>
							</tr>
							<tr>
								<td><code class="literal">org.apache.avro.generic.GenericData.Record</code></td>
								<td>Apache Avro事件是<code class="literal">GenericData.Record</code>对象(Avro是具有模式支持的数据序列化系统)</td>
							</tr>
							<tr>
								<td><code class="literal">org.w3c.dom.Node</code></td>
								<td>XML文档对象模型(DOM)。</td>
							</tr>
						</tbody>
					</table>
				</div>
			</div><br class="table-break">
			<p>
				EPL为事件表示提供了多种选择。您不需要创建新的Java类来表示事件。
			</p>
			<p>
				事件表示有以下共同点：
			</p>
			<div class="itemizedlist">
				<ul compact="compact">
					<li>
						<p>
							所有事件表示都支持嵌套、索引和映射属性(也称为属性表达式)，如下所述。嵌套级别没有限制。
						</p>
					</li>
					<li>
						<p>
							所有事件表示都提供事件类型元数据。这包括嵌套属性的类型元数据。
						</p>
					</li>
					<li>
						<p>
							所有事件表示都允许将事件本身及其部分或全部属性图转换为新事件。术语"转换"指的是选择事件本身或本身就是可嵌套属性图的事件属性，然后在进一步的语句中查询事件的属性或嵌套属性图。
						</p>
					</li>
					<li>
						<p>
							Java对象、Map、对象数组、JSON和Avro表示支持超类型。
						</p>
					</li>
				</ul>
			</div>
			<p>
				所有事件表示的API行为是相同的，只有少数例外情况。
			</p>
			<p>
				多种事件表示的好处包括：
			</p>
			<div class="itemizedlist">
				<ul compact="compact">
					<li>
						<p>
							对于已经使用其中一种支持表示形式的应用程序，在输入和输出处理时都不需要转换事件。
						</p>
					</li>
					<li>
						<p>
							事件表示是可互换的，当事件表示形式改变时，减少或消除了需要更改语句的需求，即EPL不依赖于事件是对象、Map、对象数组、JSON文档、Avro记录还是XML文档。
						</p>
					</li>
					<li>
						<p>
							事件表示是可互操作的，允许所有事件表示在同一或不同语句中互操作。
						</p>
					</li>
					<li>
						<p>
							这种选择使得可以有意识地权衡性能、易用性、演进能力以及导入或外部化事件和使用现有事件类型元数据所需的努力。
						</p>
					</li>
				</ul>
			</div>
		</div>
		<div class="sect1" lang="en-US">
			<div class="titlepage">
				<div>
					<div>
						<h2 class="title"><a id="eventrep-properties"></a>3.2. 事件属性</h2>
					</div>
				</div>
			</div><a id="d0e2690" class="indexterm"></a>
			<p>
				事件属性捕获事件的状态信息。事件属性可以是简单属性、索引属性、映射属性和嵌套事件属性。
			</p>
			<p>
				下表概述了不同类型属性及其在事件表达式中的语法：
			</p>
			<div class="table"><a id="d0e2699"></a>
				<p class="title"><b>表3.2. 事件属性类型</b></p>
				<div class="table-contents">
					<table summary="Types of Event Properties" border="1">
						<colgroup>
							<col>
							<col>
							<col>
							<col>
						</colgroup>
						<thead>
							<tr>
								<th>类型</th>
								<th>描述</th>
								<th>语法</th>
								<th>示例</th>
							</tr>
						</thead>
						<tbody>
							<tr>
								<td>简单属性</td>
								<td>具有单个可检索值的属性。</td>
								<td>
									<pre class="synopsis">名称</pre>
								</td>
								<td>
									<pre class="synopsis">sensorId</pre>
								</td>
							</tr>
							<tr>
								<td>索引属性</td>
								<td>索引属性存储有序的对象集合(所有对象类型相同)，可以通过非负整数值索引单独访问。</td>
								<td>
									<pre class="synopsis">名称[<span class="emphasis"><em>索引</em></span>]</pre>
								</td>
								<td>
									<pre class="synopsis">temperature[0]</pre>
								</td>
							</tr>
							<tr>
								<td>映射属性</td>
								<td>映射属性存储键控的对象集合(所有对象类型相同)。</td>
								<td>
									<pre class="synopsis">名称('<span class="emphasis"><em>键</em></span>')</pre>
								</td>
								<td>
									<pre class="synopsis">isTurnedOn('light')</pre>
								</td>
							</tr>
							<tr>
								<td>嵌套属性</td>
								<td>嵌套属性是存在于事件另一个属性中的属性。</td>
								<td>
									<pre class="synopsis">名称.嵌套名称</pre>
								</td>
								<td>
									<pre class="synopsis">sensor.value</pre>
								</td>
							</tr>
						</tbody>
					</table>
				</div>
			</div><br class="table-break">
			<p>
				组合也是可能的。例如，一个有效的组合可能是<code class="literal">person.address('home').street[0]</code>。
			</p>
			<p>
				您可以通过在映射或索引属性名称后的括号中放置表达式，使用任何表达式作为映射属性键或索引属性索引。请参阅下面的示例。
			</p>
			<div class="sect2" lang="en-US">
				<div class="titlepage">
					<div>
						<div>
							<h3 class="title"><a id="eventrep-properties-escaping"></a>3.2.1. 转义字符</h3>
						</div>
					</div>
				</div>
				<p>
					如果您的应用程序使用<code class="literal">java.util.Map</code>、<code class="literal">Object[]</code>(对象数组)或JSON或XML表示事件，则事件属性名称本身可能包含点('.')字符。反斜杠('\')字符可用于转义属性名称中的点字符，允许属性名称包含点字符。
				</p>
				<p>
					例如，下面的EPL期望事件类型<code class="literal">MyEvent</code>上存在名为<code class="literal">part1.part2</code>的属性：
				</p>
				<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">select part1\.part2 from MyEvent</pre>
				<p>
					有时您的事件属性可能与EPL语言关键字重叠或包含空格或其他特殊字符。在这种情况下，您可以使用反引号<code class="literal">`</code>字符来转义属性名称。
				</p>
				<p>
					下一个示例假设一个<code class="literal">Quote</code>事件有一个名为<code class="literal">order</code>的属性，而<code class="literal">order</code>也是一个保留关键字：
				</p>
				<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">select `order`, price as `price.for.goods` from Quote</pre>
				<p>
					转义映射或索引属性时，请确保反引号字符出现在映射键或索引之外。
				</p>
				<p>
					下一个EPL选择包含空格的事件属性(例如<code class="literal">candidate book</code>)、包含特殊字符(例如<code class="literal">children's books</code>)、是索引属性(例如<code class="literal">children's books[0]</code>)和具有保留关键字作为属性名称一部分的映射属性(例如<code class="literal">book select('isbn')</code>)：
				</p>
				<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">select `candidate book` , `children's books`[0], `book select`('isbn') from MyEventType</pre>
				<p>
					当引用嵌套属性时，在各个嵌套级别进行转义，例如(假设<code class="literal">MyEventType</code>有一个<code class="literal">payload</code>属性，它本身就是一个事件)：
				</p>
				<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">select payload.`candidate book`, payload.`other books`? from MyEventType</pre>
				<div xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="note">
					<h2>注意</h2>
					<p>
						Avro不支持字段名称中的点字符。
					</p>
				</div>
			</div>
			<div class="sect2" lang="en-US">
				<div class="titlepage">
					<div>
						<div>
							<h3 class="title"><a id="eventrep-properties-expression"></a>3.2.2. 表达式作为键或索引值</h3>
						</div>
					</div>
				</div>
				<p>
					键或索引表达式必须放在括号中。当使用表达式作为映射属性的键时，表达式必须返回<code class="literal">String</code>类型的值。当使用表达式作为索引属性的索引时，表达式必须返回<code class="literal">int</code>类型的值。
				</p>
				<p>
					下面的示例使用Java类来说明；同样的原则适用于所有事件表示。
				</p>
				<p>
					假设一个类声明了这些属性(为简洁起见未显示getter方法)：
				</p>
				<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">public class MyEventType {
  String myMapKey;
  int myIndexValue;
  int myInnerIndexValue;
  Map&lt;String, InnerType&gt; innerTypesMap;	// 映射属性
  InnerType[] innerTypesArray; // 索引属性
}

public class InnerType {
  String name;
  int[] ids;
}</pre>
				<p>
					演示将表达式作为映射键或索引的示例语句是：
				</p>
				<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">select innerTypesMap('somekey'),  // 返回'somekey'的映射值
  innerTypesMap(myMapKey),        // 返回myMapKey值的映射值(表达式)
  innerTypesArray[1],             // 返回索引1处的数组值
  innerTypesArray(myIndexValue)   // 返回myIndexValue索引处的数组值(表达式)
  from MyEventType</pre>
				<p>
					点运算符可用于访问由映射或索引属性返回的值对象上的方法。通过使用点运算符，语法遵循<a class="xref" href="epl-operator.html#epl-operator-ref-dot" title="9.7. 点运算符">第9.7节"点运算符"</a>中描述的链式方法调用。
				</p>
				<p>
					演示点运算符以及将表达式作为映射键或索引的示例语句是：
				</p>
				<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class=""> select innerTypesMap('somekey').ids[1],
  innerTypesMap(myMapKey).getIds(myIndexValue),
  innerTypesArray[1].ids[2],
  innerTypesArray(myIndexValue).getIds(myInnerIndexValue)
  from MyEventType</pre>
				<p>
					请注意以下限制：
				</p>
				<div class="itemizedlist">
					<ul compact="compact">
						<li>
							<p>
								索引属性的方括号语法不允许表达式，并且需要常量索引值。
							</p>
						</li>
						<li>
							<p>
								当对具有表达式作为映射键或索引的映射或索引属性使用点运算符时，必须遵循链式方法调用语法。
							</p>
						</li>
					</ul>
				</div>
			</div>
		</div>
		<div class="sect1" lang="en-US">
			<div class="titlepage">
				<div>
					<div>
						<h2 class="title"><a id="eventrep-dyncproperties"></a>3.3. 动态事件属性</h2>
					</div>
				</div>
			</div><a id="d0e2886" class="indexterm"></a><a id="d0e2889" class="indexterm"></a>
			<p>
				动态(未检查)属性是在语句编译时不需要知道的事件属性。这些属性在运行时解析：它们提供了鸭子类型功能。
			</p>
			<p>
				动态属性的理念是，对于给定的底层事件表示，您并不总是提前知道所有属性。底层事件可能具有在语句编译时不知道的附加属性，您希望查询这些属性。这个概念对于表示丰富的面向对象领域模型的事件特别有用。
			</p>
			<p>
				动态属性的语法由属性名称和问号组成。索引属性、映射属性和嵌套属性也可以是动态属性：
			</p>
			<div class="table"><a id="d0e2900"></a>
				<p class="title"><b>表3.3. 事件属性类型</b></p>
				<div class="table-contents">
					<table summary="Types of Event Properties" border="1">
						<colgroup>
							<col>
							<col>
						</colgroup>
						<thead>
							<tr>
								<th>类型</th>
								<th>语法</th>
							</tr>
						</thead>
						<tbody>
							<tr>
								<td>动态简单属性</td>
								<td>
									<pre class="synopsis">名称?</pre>
								</td>
							</tr>
							<tr>
								<td>动态索引属性</td>
								<td>
									<pre class="synopsis">名称[<span class="emphasis"><em>索引</em></span>]?</pre>
								</td>
							</tr>
							<tr>
								<td>动态映射属性</td>
								<td>
									<pre class="synopsis">名称('<span class="emphasis"><em>键</em></span>')?</pre>
								</td>
							</tr>
							<tr>
								<td>动态嵌套属性</td>
								<td>
									<pre class="synopsis">名称?.嵌套属性名称</pre>
								</td>
							</tr>
						</tbody>
					</table>
				</div>
			</div><br class="table-break">
			<p>
				动态属性总是返回<code class="literal">java.lang.Object</code>类型。此外，如果动态属性在运行时处理的事件上不存在，则动态属性返回<code class="literal">null</code>值。
			</p>
			<p>
				举个例子，考虑一个OrderEvent事件，它提供了一个"item"属性。"item"属性的类型是<code class="literal">Object</code>，并持有对Service或Product实例的引用。
			</p>
			<p>
				假设Service和Product类都提供了一个名为"price"的属性。通过动态属性，您可以指定一个语句，从任一对象(Service或Product)获取price属性：
			</p>
			<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">select item.price? from OrderEvent</pre>
			<p>
				作为第二个例子，假设Service类包含一个"serviceName"属性，而Product类没有这个属性。以下语句返回Service对象的"serviceName"属性值。对于没有"serviceName"属性的Product对象，它返回<code class="literal">null</code>值：
			</p>
			<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">select item.serviceName? from OrderEvent</pre>
			<p>
				考虑OrderEvent有多个实现类的情况，其中一些具有"timestamp"属性。下一个语句返回具有该属性的OrderEvent接口实现的timestamp属性：
			</p>
			<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">select timestamp? from OrderEvent</pre>
			<p>
				如上所示的语句返回一个名为"timestamp?"的列，类型为<code class="literal">Object</code>。
			</p>
			<p>
				当动态属性是嵌套的时，动态属性下的所有属性也被视为动态属性。在下面的例子中，语句要求"detail"动态属性返回的对象的"direction"属性：
			</p>
			<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">select detail?.direction from OrderEvent</pre>
			<p>
				上面等同于：
			</p>
			<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">select detail?.direction? from OrderEvent</pre>
			<p>
				通常与动态属性一起使用的函数有：
			</p>
			<div class="itemizedlist">
				<ul>
					<li>
						<p>
							<code class="literal">cast</code>函数将动态属性(或表达式的值)的值转换为给定类型。
						</p>
					</li>
					<li>
						<p>
							<code class="literal">exists</code>函数检查动态属性是否存在。如果事件具有该名称的属性，则返回<code class="literal">true</code>，如果该事件上不存在该属性，则返回false。
						</p>
					</li>
					<li>
						<p>
							<code class="literal">instanceof</code>函数检查动态属性(或表达式的值)的值是否是任何给定类型。
						</p>
					</li>
					<li>
						<p>
							<code class="literal">typeof</code>函数返回动态属性的字符串类型名称。
						</p>
					</li>
				</ul>
			</div>
		</div>
		<div class="sect1" lang="en-US">
			<div class="titlepage">
				<div>
					<div>
						<h2 class="title"><a id="eventrep-fragment"></a>3.4. 片段与片段类型</h2>
					</div>
				</div>
			</div>
			<p>
				有时一个事件可以具有本身就是事件的属性。EPL使用术语<strong>片段</strong>和<strong>片段类型</strong>来表示这样的事件片段。最好的例子是一个匹配两个或更多事件的模式，输出事件将匹配的事件作为片段包含。换句话说，输出事件可以是由片段组成的复合事件。
			</p>
			<p>
				片段具有与其封闭复合事件相同的元数据可用。封闭复合事件的元数据包含关于哪些属性是片段，或具有可以表示为片段并因此作为事件本身的属性值的信息。
			</p>
			<p>
				片段和类型元数据可以让您的应用程序导航复合事件，而无需使用Java反射API，并减少与底层事件表示的耦合。
				该API在<a class="xref" href="apiruntime.html#apiruntime-statement-event" title="16.5.5. 事件与事件类型">第16.5.5节"事件与事件类型"</a>中有进一步描述。
			</p>
		</div>
		<div class="sect1" lang="en-US">
			<div class="titlepage">
				<div>
					<div>
						<h2 class="title"><a id="eventrep_comparing"></a>3.5. 事件表示方法的比较</h2>
					</div>
				</div>
			</div>
			<p>
				关于事件表示的更多信息可以在附录中找到。链接如下：
			</p>
			<div class="table"><a id="d0e3036"></a>
				<p class="title"><b>表3.4. 事件表示方法比较</b></p>
				<div class="table-contents">
					<table summary="Comparing Event Representations" border="1">
						<colgroup>
							<col>
							<col>
						</colgroup>
						<thead>
							<tr>
								<th>事件表示</th>
								<th>更多信息和示例</th>
							</tr>
						</thead>
						<tbody>
							<tr>
								<td>Java对象(POJO/Bean或其他)</td>
								<td><a class="xref" href="appendix_eventrepbean.html" title="附录 D. 事件表示：普通Java对象事件">附录D，<i>事件表示：普通Java对象事件</i></a></td>
							</tr>
							<tr>
								<td>Map</td>
								<td><a class="xref" href="appendix_eventrepmap.html" title="附录 E. 事件表示：java.util.Map事件">附录E，<i>事件表示：java.util.Map事件</i></a></td>
							</tr>
							<tr>
								<td>对象数组</td>
								<td><a class="xref" href="appendix_eventrepoa.html" title="附录 F. 事件表示：对象数组(Object[])事件">附录F，<i>事件表示：对象数组(Object[])事件</i></a></td>
							</tr>
							<tr>
								<td>JSON</td>
								<td><a class="xref" href="appendix_eventrepjson.html" title="附录 G. 事件表示：JSON事件">附录G，<i>事件表示：JSON事件</i></a></td>
							</tr>
							<tr>
								<td>Avro</td>
								<td><a class="xref" href="appendix_eventrepavro.html" title="附录 H. 事件表示：Avro事件(org.apache.avro.generic.GenericData.Record)">附录H，<i>事件表示：Avro事件(org.apache.avro.generic.GenericData.Record)</i></a></td>
							</tr>
							<tr>
								<td>XML文档</td>
								<td><a class="xref" href="appendix_eventrepxml.html" title="附录 I. 事件表示：org.w3c.dom.Node XML事件">附录I，<i>事件表示：org.w3c.dom.Node XML事件</i></a></td>
							</tr>
						</tbody>
					</table>
				</div>
			</div><br class="table-break">
			<div class="sect2" lang="en-US">
				<div class="titlepage">
					<div>
						<div>
							<h3 class="title"><a id="eventrep_comparing_incoming"></a>3.5.1. 输入事件</h3>
						</div>
					</div>
				</div>
				<p>
					为了将输入事件发送到运行时进行处理，您的应用程序使用<code class="literal">EPEventService</code>接口上的send-event方法之一：
				</p>
				<div class="table"><a id="d0e3087"></a>
					<p class="title"><b>表3.5. EPEventService发送事件方法</b></p>
					<div class="table-contents">
						<table summary="EPEventService Send-Event Methods" border="1">
							<colgroup>
								<col>
								<col>
							</colgroup>
							<thead>
								<tr>
									<th>事件表示</th>
									<th>处理事件的方法</th>
								</tr>
							</thead>
							<tbody>
								<tr>
									<td>Java对象(POJO/Bean或其他)</td>
									<td>
										<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">sendEventBean(Object event, String eventTypeName)</pre>
									</td>
								</tr>
								<tr>
									<td>Map</td>
									<td>
										<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">sendEventMap(Map map, String mapEventTypeName)</pre>
									</td>
								</tr>
								<tr>
									<td>对象数组</td>
									<td>
										<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">sendEventObjectArray(Object[] objectarray, String objectArrayEventTypeName)</pre>
									</td>
								</tr>
								<tr>
									<td>JSON</td>
									<td>
										<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">sendEventJson(String json, String jsonEventTypeName)</pre>
									</td>
								</tr>
								<tr>
									<td>Avro</td>
									<td>
										<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">sendEventAvro(Object avroGenericDataDotRecord, String avroEventTypeName)</pre>
									</td>
								</tr>
								<tr>
									<td>XML文档</td>
									<td>
										<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">sendEventXMLDOM(org.w3c.dom.Node node, String eventTypeName)</pre>
									</td>
								</tr>
							</tbody>
						</table>
					</div>
				</div><br class="table-break">
				<p>
					请在各附录中查找示例。
				</p>
			</div>
			<div class="sect2" lang="en-US">
				<div class="titlepage">
					<div>
						<div>
							<h3 class="title"><a id="eventrep_comparing_outgoing"></a>3.5.2. 输出事件</h3>
						</div>
					</div>
				</div>
				<p>
					<code class="literal">StatementUpdateListener</code>接口接收语句输出。输出事件可以是以下表示形式之一：
				</p>
				<div class="table"><a id="d0e3146"></a>
					<p class="title"><b>表3.6. 接收事件的注解</b></p>
					<div class="table-contents">
						<table summary="Annotation for Receiving Events" border="1">
							<colgroup>
								<col>
								<col>
							</colgroup>
							<thead>
								<tr>
									<th>事件表示</th>
									<th>注解</th>
								</tr>
							</thead>
							<tbody>
								<tr>
									<td>Java对象(POJO/Bean或其他)</td>
									<td>
										<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">N/A</pre>
									</td>
								</tr>
								<tr>
									<td>Map</td>
									<td>
										<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">@EventRepresentation(map)</pre>
									</td>
								</tr>
								<tr>
									<td>对象数组</td>
									<td>
										<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">@EventRepresentation(objectarray)</pre>
									</td>
								</tr>
								<tr>
									<td>JSON</td>
									<td>
										<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">@EventRepresentation(json)</pre>
									</td>
								</tr>
								<tr>
									<td>Avro</td>
									<td>
										<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">@EventRepresentation(avro)</pre>
									</td>
								</tr>
								<tr>
									<td>XML文档</td>
									<td>
										<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">N/A</pre>
									</td>
								</tr>
							</tbody>
						</table>
					</div>
				</div><br class="table-break">
				<p>
					请在各附录中查找示例。
				</p>
			</div>
			<div class="sect2" lang="en-US">
				<div class="titlepage">
					<div>
						<div>
							<h3 class="title"><a id="eventrep_comparing_schema"></a>3.5.3. 模式</h3>
						</div>
					</div>
				</div>
				<p>
					create-schema子句可用于定义事件类型及其事件表示。
				</p>
				<div class="table"><a id="d0e3202"></a>
					<p class="title"><b>表3.7. Create-Schema</b></p>
					<div class="table-contents">
						<table summary="Create-Schema" border="1">
							<colgroup>
								<col>
								<col>
							</colgroup>
							<thead>
								<tr>
									<th>事件表示</th>
									<th>注解</th>
								</tr>
							</thead>
							<tbody>
								<tr>
									<td>Java对象(POJO/Bean或其他)</td>
									<td>
										<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create schema <span xmlns="http://www.w3.org/1999/xhtml" class="emphasis"><em>名称</em></span> as <span xmlns="http://www.w3.org/1999/xhtml" class="emphasis"><em>类名</em></span></pre>
									</td>
								</tr>
								<tr>
									<td>Map</td>
									<td>
										<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create map schema <span xmlns="http://www.w3.org/1999/xhtml" class="emphasis"><em>名称</em></span> as (...)</pre>
									</td>
								</tr>
								<tr>
									<td>对象数组</td>
									<td>
										<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create objectarray schema <span xmlns="http://www.w3.org/1999/xhtml" class="emphasis"><em>名称</em></span> as (...)</pre>
									</td>
								</tr>
								<tr>
									<td>JSON</td>
									<td>
										<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create json schema <span xmlns="http://www.w3.org/1999/xhtml" class="emphasis"><em>名称</em></span> as (...)</pre>
									</td>
								</tr>
								<tr>
									<td>Avro</td>
									<td>
										<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create avro schema <span xmlns="http://www.w3.org/1999/xhtml" class="emphasis"><em>名称</em></span> as (...)</pre>
									</td>
								</tr>
								<tr>
									<td>XML文档</td>
									<td>
										<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">@XMLSchema(...) create xml schema <span xmlns="http://www.w3.org/1999/xhtml" class="emphasis"><em>名称</em></span> as ()</pre>
									</td>
								</tr>
							</tbody>
						</table>
					</div>
				</div><br class="table-break">
				<p>
					您的语句可以使用<code class="literal">create schema</code>和<code class="literal">insert into</code>来定义事件类型并生成该类型的事件。
				</p>
				<p>
					在下面的示例中，第一个语句声明了一个模式，第二个语句根据该模式插入事件：
				</p>
				<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create map schema ParkingEvent as (carId string, driverName string)</pre>
				<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">insert into ParkingEvent select carId, 'jim' as driverName from CarArrivalEvent</pre>
				<p>
					更多示例请参见<a class="xref" href="epl_clauses.html#epl_createschema" title="5.15. 声明事件类型：Create Schema">第5.15节"声明事件类型：Create Schema"</a>。
				</p>
			</div>
			<div class="sect2" lang="en-US">
				<div class="titlepage">
					<div>
						<div>
							<h3 class="title"><a id="eventrep_comparing_advantages"></a>3.5.4. 对比表</h3>
						</div>
					</div>
				</div>
				<p>
					Java对象、Map、对象数组、JSON、Avro和XML文档每种事件表示都有其优缺点，总结如下表：
				</p>
				<div class="table"><a id="d0e3294"></a>
					<p class="title"><b>表3.8. 事件表示方法比较</b></p>
					<div class="table-contents">
						<table summary="Comparing Event Representations" border="1">
							<colgroup>
								<col>
								<col>
								<col>
								<col>
								<col>
								<col>
								<col>
							</colgroup>
							<thead>
								<tr>
									<th> </th>
									<th>Java对象(POJO/Bean或其他)</th>
									<th>Map</th>
									<th>对象数组</th>
									<th>JSON</th>
									<th>Avro</th>
									<th>XML文档</th>
								</tr>
							</thead>
							<tbody>
								<tr>
									<td>性能</td>
									<td>优秀</td>
									<td>良好</td>
									<td>优秀</td>
									<td>优秀</td>
									<td>非常好</td>
									<td>不可比，取决于XPath的使用</td>
								</tr>
								<tr>
									<td>内存使用</td>
									<td>小</td>
									<td>中等</td>
									<td>小</td>
									<td>小</td>
									<td>小</td>
									<td>取决于使用的DOM和XPath实现，可能很大</td>
								</tr>
								<tr>
									<td>调用事件上的方法</td>
									<td>是</td>
									<td>是，如果包含对象</td>
									<td>是，如果包含对象</td>
									<td>否</td>
									<td>否</td>
									<td>否</td>
								</tr>
								<tr>
									<td>嵌套、索引、映射和动态属性</td>
									<td>是</td>
									<td>是</td>
									<td>是</td>
									<td>是</td>
									<td>是</td>
									<td>是</td>
								</tr>
								<tr>
									<td>粗粒度事件语法</td>
									<td>是</td>
									<td>是</td>
									<td>是</td>
									<td>是</td>
									<td>是</td>
									<td>是</td>
								</tr>
								<tr>
									<td>插入到该表示</td>
									<td>是</td>
									<td>是</td>
									<td>是</td>
									<td>是</td>
									<td>是</td>
									<td>否</td>
								</tr>
								<tr>
									<td>Create-schema语法</td>
									<td>是</td>
									<td>是</td>
									<td>是</td>
									<td>是</td>
									<td>是</td>
									<td>是</td>
								</tr>
								<tr>
									<td>对象是自描述的</td>
									<td>是</td>
									<td>是</td>
									<td>否</td>
									<td>是</td>
									<td>是</td>
									<td>是</td>
								</tr>
								<tr>
									<td>超类型</td>
									<td>多个</td>
									<td>多个</td>
									<td>单个</td>
									<td>单个</td>
									<td>单个</td>
									<td>否</td>
								</tr>
							</tbody>
						</table>
					</div>
				</div><br class="table-break">
			</div>
		</div>
		<div class="sect1" lang="en-US">
			<div class="titlepage">
				<div>
					<div>
						<h2 class="title"><a id="eventrep-generictuple"></a>3.6. 通用元组支持</h2>
					</div>
				</div>
			</div>
			<p>
				EPL不需要固定的元组结构，完全支持通用元组。事件属性可以在运行时定义、添加到现有类型并进行查询。
			</p>
			<p>
				支持通用元组的设施包括：
			</p>
			<div class="itemizedlist">
				<ul>
					<li>
						<p>动态属性允许查询未定义的属性，参见<a class="xref" href="event_representation.html#eventrep-dyncproperties" title="3.3. 动态事件属性">第3.3节"动态事件属性"</a>。</p>
					</li>
					<li>
						<p>用于需要强类型数据的操作的<code class="literal">cast</code>函数，参见<a class="xref" href="functionreference.html#epl-single-row-function-cast" title="10.1.2. Cast函数">第10.1.2节"Cast函数"</a>。</p>
					</li>
					<li>
						<p>用于向超类型添加属性的类型继承，参见<a class="xref" href="epl_clauses.html#epl_createschema" title="5.15. 声明事件类型：Create Schema">第5.15节"声明事件类型：Create Schema"</a></p>
					</li>
					<li>
						<p>Map事件表示，因为它允许任何map键成为事件属性，参见<a class="xref" href="appendix_eventrepmap.html" title="附录 E. 事件表示：java.util.Map事件">附录E，<i>事件表示：java.util.Map事件</i></a></p>
					</li>
					<li>
						<p>JSON事件表示，因为它允许任何JSON值(JSON对象、数组、所有JSON类型)成为事件属性，参见<a class="xref" href="appendix_eventrepjson.html" title="附录 G. 事件表示：JSON事件">附录G，<i>事件表示：JSON事件</i></a></p>
					</li>
					<li>
						<p>Avro事件表示，因为它允许任何Avro字段成为事件属性，参见<a class="xref" href="appendix_eventrepavro.html" title="附录 H. 事件表示：Avro事件(org.apache.avro.generic.GenericData.Record)">附录H，<i>事件表示：Avro事件(org.apache.avro.generic.GenericData.Record)</i></a></p>
					</li>
					<li>
						<p>POJO事件表示，因为getter方法和字段可以被动态发现成为事件属性，参见<a class="xref" href="appendix_eventrepbean.html" title="附录 D. 事件表示：普通Java对象事件">附录D，<i>事件表示：普通Java对象事件</i></a></p>
					</li>
					<li>
						<p>XML事件表示，因为DOM可以有任何属性或嵌套元素，并且不需要模式，参见<a class="xref" href="appendix_eventrepxml.html" title="附录 I. 事件表示：org.w3c.dom.Node XML事件">附录I，<i>事件表示：org.w3c.dom.Node XML事件</i></a></p>
					</li>
					<li>
						<p>事件类型可以使用<code class="literal">create schema</code>和部署API在运行时部署和取消部署</p>
					</li>
				</ul>
			</div>
			<p>
				不需要为每种元组类型显式创建事件类型。完全不需要为元组类型创建类。事件可以是任意对象。
			</p>
			<p>
				编译器使用可用的类型信息：编译器可以根据已知属性和类型验证您的语句，防止您作为EPL设计者犯错误。
				编译器不验证动态属性，这些属性在运行时可能返回<code class="literal">null</code>。
				如果没有类型信息可用，则属性被假定为返回<code class="literal">java.lang.Object</code>类型的值。
			</p>
			<p>
				例如，假设您需要一个通用元组，并且有<code class="literal">Map</code>事件：
			</p>
			<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">create schema GenericTuple()</pre>
			<p>
				创建使用动态属性的语句，如下面的EPL所示，它将timestamp值转换为<code class="literal">long</code>类型值并输出时分秒字符串：
			</p>
			<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">select cast(timestamp?, long).format('hh mm ss') from GenericTuple</pre>
			<p>
				像这样发送事件：
			</p>
			<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">Map&lt;String, Object&gt; genericEvent = new HashMap&lt;&gt;();
genericEvent.put("timestamp", new Date().getTime());
genericEvent.put("some_other_property", "hello");
runtime.getEventService().sendEventMap(genericEvent, "GenericTuple");</pre>
		</div>
		<div class="sect1" lang="en-US">
			<div class="titlepage">
				<div>
					<div>
						<h2 class="title"><a id="eventrep-update"></a>3.7. 事件更新、合并与版本控制</h2>
					</div>
				</div>
			</div><a id="d0e3538" class="indexterm"></a><a id="d0e3543" class="indexterm"></a>
			<p>
				总结来说，事件是对过去发生的动作或状态变化的不可变记录，事件属性包含有关事件的有用信息。
			</p>
			<p>
				事件对运行时感兴趣的时间长度(保留时间)取决于您的语句，特别是语句的数据窗口、模式和输出速率限制子句。
			</p>
			<p>
				在事件的保留时间内，可能会获得有关事件的更多信息，例如附加属性或对现有属性的更改。
				EPL提供了两种处理事件更新的概念。
			</p>
			<p>
				第一种处理更新事件的方法是<code class="literal">update istream</code>子句，详见<a class="xref" href="epl_clauses.html#epl-update" title="5.20. 更新插入流：Update IStream子句">第5.20节"更新插入流：Update IStream子句"</a>。当您需要在事件进入流时更新事件，在事件被任何特定消费语句评估之前，这非常有用。
			</p>
			<p>
				第二种更新事件的方法是<code class="literal">on-merge</code>和<code class="literal">on-update</code>子句，仅用于表和命名窗口，详见<a class="xref" href="nwtable.html#named_upsert" title="6.8. 使用On-Merge子句触发Upsert">第6.8节"使用On-Merge子句触发Upsert"</a>和<a class="xref" href="nwtable.html#named_update" title="6.6. 更新数据：On Update子句">第6.6节"更新数据：On Update子句"</a>。On-merge类似于SQL的<code class="literal">merge</code>子句，提供所谓的"Upsert"操作：更新现有事件，如果没有找到现有事件，则插入新事件，所有这些都在单个语句提供的原子操作中完成。
				On-update可用于更新表或命名窗口中行的单个属性。
			</p>
		</div>
		<div class="sect1" lang="en-US">
			<div class="titlepage">
				<div>
					<div>
						<h2 class="title"><a id="eventrep-coarse"></a>3.8. 粗粒度事件</h2>
					</div>
				</div>
			</div><a id="d0e3579" class="indexterm"></a><a id="d0e3584" class="indexterm"></a>
			<p>
				您的应用程序事件可能由相当全面、粗粒度的结构或文档组成。例如在B2B集成场景中，XML文档或其他事件对象可以是丰富的深度嵌套的事件属性图。
			</p>
			<p>
				为了从粗粒度事件中提取信息或对事件属性图中的行执行批量操作，EPL提供了一种方便的语法：
				当在模式或<code class="literal">select</code>子句中指定过滤表达式时，它可以包含包含事件选择语法，详见<a class="xref" href="epl_clauses.html#epl-containedeventselect" title="5.19. 包含事件选择">第5.19节"包含事件选择"</a>。
			</p>
		</div>
		<div class="sect1" lang="en-US">
			<div class="titlepage">
				<div>
					<div>
						<h2 class="title"><a id="eventrep-insertinto"></a>3.9. 通过<code class="literal">Insert Into</code>实例化并填充事件对象</h2>
					</div>
				</div>
			</div><a id="d0e3603" class="indexterm"></a>
			<p>
				对于NEsper .NET，另见<a class="xref" href="appendix_dotnet.html#appendix_dotnet_eventrep_insertinto" title="J.11. .NET通过Insert Into实例化并填充事件对象">第J.11节".NET通过Insert Into实例化并填充事件对象"</a>。
			</p>
			<p>
				<code class="literal">insert into</code>子句可以直接从<code class="literal">select</code>子句表达式的结果实例化并填充Java对象事件、<code class="literal">java.util.Map</code>事件和<code class="literal">Object[]</code>(对象数组)事件的新实例。只需在<code class="literal">insert into</code>子句中使用事件类型名称作为流名称，如<a class="xref" href="epl_clauses.html#epl-insert-into" title="5.10. 合并流和连续插入：Insert Into子句">第5.10节"合并流和连续插入：Insert Into子句"</a>中所述。
			</p>
			<p>
				如果您有一个由表达式(例如单行函数或静态方法调用)返回的现有Java对象实例，您可以将该表达式结果对象转置到流中。这在<a class="xref" href="epl_clauses.html#insert-into-expression" title="5.10.7. 转置表达式结果">第5.10.7节"转置表达式结果"</a>和<a class="xref" href="functionreference.html#functionreference-transpose" title="10.4. Select-Clause转置函数">第10.4节"Select-Clause转置函数"</a>中有进一步描述。
			</p>
			<p>
				<code class="literal">select</code>和<code class="literal">insert into</code>子句中指定的列名必须与要填充的事件对象(目标事件类型)中可用的可写属性匹配。<code class="literal">select</code>子句中任何表达式的表达式结果类型也必须与目标事件类型的属性类型兼容。
			</p>
			<p>
				如果要填充基于POJO的事件类型并且该类提供了匹配的构造函数，则<code class="literal">select</code>子句中表达式的表达式结果类型必须与构造函数参数按构造函数列出的顺序兼容。在这种情况下，<code class="literal">insert into</code>子句列名不相关。
			</p>
			<p>
				考虑以下示例语句：
			</p>
			<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">insert into com.mycompany.NewEmployeeEvent 
select fname as firstName, lname as lastName from HRSystemEvent</pre>
			<p>
				上面的示例指定了<code class="literal">NewEmployeeEvent</code>的完全限定类名。运行时为每个结果行实例化<code class="literal">NewEmployeeEvent</code>，并从<code class="literal">select</code>子句表达式的结果填充每个实例的<code class="literal">firstName</code>和<code class="literal">lastName</code>属性。示例中的<code class="literal">HRSystemEvent</code>假定具有<code class="literal">lname</code>和<code class="literal">fname</code>属性，并且具有setter方法和默认构造函数，或匹配的构造函数。
			</p>
			<p>
				注意示例如何使用<code class="literal">as</code>关键字分配与<code class="literal">NewEmployeeEvent</code>目标事件的属性名称匹配的列名。如果源事件和目标事件的属性名称相同，则不需要<code class="literal">as</code>关键字。
			</p>
			<p>
				下一个示例是另一种形式，在<code class="literal">insert into</code>子句中指定属性名称。该示例还假定<code class="literal">NewEmployeeEvent</code>已通过配置定义或导入，因为它没有指定事件类包名：
			</p>
			<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">insert into NewEmployeeEvent(firstName, lastName) 
select fname, lname from HRSystemEvent</pre>
			<p>
				最后，这个示例填充<code class="literal">HRSystemEvent</code>事件。该示例填充事件中<code class="literal">type</code>属性值为'NEW'的事件，并用'HIRED'填充一个新的事件对象，将<code class="literal">fname</code>和<code class="literal">lname</code>属性值复制到新的事件对象：
			</p>
			<pre xmlns="" xmlns:d="http://docbook.org/ns/docbook" xmlns:rf="java:org.jboss.highlight.XhtmlRendererFactory" class="">insert into HRSystemEvent 
select fname, lname, 'HIRED' as type from HRSystemEvent(type='NEW')</pre>
			<p>
				<code class="literal">select</code>或<code class="literal">insert into</code>子句列名与目标事件类型的属性名称的匹配是区分大小写的。您可以指定目标事件类型中所有可用列的子集。允许使用通配符(<code class="literal">*</code>)并复制事件或连接中多个事件的所有字段。
			</p>
			<p>
				对于Java对象事件，您的事件类必须根据JavaBean约定提供setter方法，或者提供一个匹配的构造函数。如果事件类提供setter方法，该类还应提供不带参数的默认构造函数。如果事件类提供匹配的构造函数，则不需要setter方法。如果您的事件类没有默认构造函数和setter方法，或匹配的构造函数，您的应用程序可以通过<code class="literal">ConfigurationEventTypeLegacy</code>配置工厂方法。如果您的事件类没有默认构造函数并且没有提供工厂方法，运行时在Oracle JVM中使用<code class="literal">sun.reflect.ReflectionFactory</code>，注意在这种情况下成员变量不会初始化为分配的默认值。
			</p>
			<p>
				编译器遵循Java标准进行扩展，在允许扩展类型转换而不会丢失精度的情况下自动执行扩展，包括装箱和基本类型以及BigInteger和BigDecimal。
			</p>
			<p>
				当将数组类型的属性插入到Java、Map类型、对象数组或JSON底层事件中时，事件定义应将目标属性声明为数组(Avro使用集合)。
			</p>
			<p>
				请注意以下限制：
			</p>
			<div class="itemizedlist">
				<ul compact="compact">
					<li>
						<p>
							使用XML <code class="literal">org.w3c.dom.Node</code>底层事件对象的事件类型不能作为<code class="literal">insert into</code>子句的目标。
						</p>
					</li>
				</ul>
			</div>
		</div>
		<div class="sect1" lang="en-US">
			<div class="titlepage">
				<div>
					<div>
						<h2 class="title"><a id="eventrep_identification"></a>3.10. 事件类型唯一性</h2>
					</div>
				</div>
			</div>
			<p>
				预配置事件类型的事件类型名称在编译器和运行时中都是唯一的。
			</p>
			<p>
				由<code class="literal">create schema</code>分配的事件类型名称通过部署ID和事件类型名称的组合在编译器和运行时中是唯一的。
			</p>
			<p>
				在运行时进行内部查找时，运行时计算CRC32值对。通常您不需要担心CRC32值，因为冲突非常不可能发生，编译器和运行时通过抛出编译时或部署时异常来指示相关冲突。
				对于预配置事件类型，类型名称的CRC32在运行时中必须是唯一的。
				对于由<code class="literal">create schema</code>分配的事件类型，部署ID的CRC32和事件类型名称的CRC32的组合在运行时中必须是唯一的。
			</p>
		</div>
	</div>
	<ul xmlns:d="http://docbook.org/ns/docbook" class="docnav">
		<li class="previous"><a accesskey="p" href="processingmodel.html"><strong>上一章</strong>第2章 基本概念</a></li>
		<li class="up"><a accesskey="u" href="#"><strong>返回顶部</strong></a></li>
		<li class="home"><a accesskey="h" href="index.html"><strong>首页</strong></a></li>
		<li class="next"><a accesskey="n" href="context.html"><strong>下一章</strong>第4章 上下文与上下文分区</a></li>
	</ul>
</body>

</html>